import { Controller } from 'egg';
import {Op} from 'sequelize'
//招聘管理接口
export default class  CategoryController extends Controller {
    //分类列表接口
    /**
     * @api {get} /manage/category_list 分类列表
     * @apiName manageCategoryList
     * @apiGroup Category
     * @apiVersion 1.0.0
     * @apiDescription 分类列表
     * @apiParam {String} keyword  关键字查询
     * @apiParam {Number} page  页面位置
     * @apiParam {Number} page_size  页面尺寸
     * @apiParam {Number} is_page  是否分页
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 查询结果数据结构（is_page为1时为对象为0时则为数组）
     * @apiSuccess {Object[]} data.data_info 分类列表
     * @apiSuccess {String} data.data_info.category_id 类型ID
     * @apiSuccess {String} data.data_info.category_name 类型名称
     * @apiSuccess {String} data.data_info.create_time 创建时间
     * @apiSuccess {String} data.data_count 数据总数
     * @apiSuccess {String} data.page_count 页码总数
     * @apiSuccess {Number} data.category_id 类型ID
     * @apiSuccess {String} data.category_name 类型名称
     * @apiSuccess {String} data.create_time 类型名称
     *
     */
     /**
     * 查询所有分类
     * 参数：
     *  condition 检索条件
     * 输出：
     * {Number} code 返回状态码 0失败  200成功
     * {String} message 返回状态对应提示消息
     * {Object} data 查询结果数据结构（is_page为1时为对象为0时则为数组）
     * {Object[]} data.data_info 分类列表
     * {String} data.data_info.category_id 类型ID
     * {String} data.data_info.category_name 类型名称
     * {String} data.data_info.create_time 创建时间
     * {String} data.data_count 数据总数
     * {String} data.page_count 页码总数
     * {Number} data.category_id 类型ID
     * {String} data.category_name 类型名称
     * {String} data.create_time 类型名称
     * 过程：
     *  构建查询条件
     *  查询数据，返回结果
     */
    async list(){
        const {ctx}=this;
        const {query}=ctx.request;
        let condition={};
        try {
            if(query.keyword){
                let keyword=query.keyword;
                condition['category_name']={[Op.like]: '%'+ keyword +'%'};
            }
            let order_condition=[
                ['create_time', 'DESC'],             
            ];
            //ctx.helper.sort_order(order_condition);
            if(parseInt(query.is_page)){

                ctx.body=await ctx.service.common.find_and_count_all(condition,order_condition,query,'Category');
            }else{
                ctx.body=await ctx.service.common.find_all(condition,order_condition,"Category");
            }
        } catch (error) {
            ctx.body=ctx.helper.error_result("查询异常");
        }
    }

    //分类新增
    /**
     * @api {post} /manage/category_add 分类新增
     * @apiName categoryAdd
     * @apiGroup Category
     * @apiVersion 1.0.0
     * @apiDescription 分类新增
     * @apiParam {String} category_name  职位名称
     * @apiParam {Number} sub_id  子类型ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 返回数据
     * @apiSuccess {Number} data.category_id 类型ID
     */
    /**
     * 新增分类：
     * 创建分类记录，如果有关联的sub_id可直接关联一个sub_id
     */
    async add(){
        const {ctx,app}=this;
        const {body}=ctx.request;
        if(!body.category_name){
            return ctx.body=ctx.helper.error_result("需要指定类型名称");
        }        
        try {
            let result=await app.model.Category.create(body);
            if(body.sub_id){
                let count=await app.model.SubCategory.count({where:{
                    category_id:result['category_id'],
                    sub_id:body['sub_id']
                }})
                if(count<=0){
                    await app.model.SubCategory.create({
                        sub_id:body['sub_id'],
                        category_id:result['category_id']
                    })
                }
            }
            ctx.body=ctx.helper.success_result("操作成功",{category_id:result&&result['category_id'] ? result['category_id'] : null});   
        } catch (error) {
            console.log(error);
            ctx.body=ctx.helper.error_result("添加分类失败");
        }
    }
    //分类修改
    /**
     * @api {post} /manage/category_update 分类修改
     * @apiName categoryUpdate
     * @apiGroup Category
     * @apiVersion 1.0.0
     * @apiDescription 分类修改
     * @apiParam {String} category_id  分类ID
     * @apiParam {String} category_name  分类名称
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     *
     */ 
    /**
     * 修改分类：
     * 更新分类数据
     */
    async update(){
        const {ctx,app}=this;
        const {body}=ctx.request;
        if(!body.category_id){
            return ctx.body=ctx.helper.error_result("需要指定要修改的分类ID");
        }
        let param=ctx.helper.not_null_filter(body);
        let condition={
            category_id:body.category_id
        }
        try {
            let result=await app.model.Category.update(param,{where:condition});
            ctx.body=result&&result[0] ? ctx.helper.success_result("操作成功") : ctx.helper.success_result("未修改数据");
        } catch (error) {
            ctx.body=ctx.helper.success_result("修改失败");
        }
    }
    //分类修改
    /**
     * @api {post} /manage/category_del 分类删除
     * @apiName categoryDel
     * @apiGroup Category
     * @apiVersion 1.0.0
     * @apiDescription 分类删除
     * @apiParam {Number} category_id  分类ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     *
     */
    /**
     * 删除分类：
     * 删除该类型关联的类型子类型关联数据，删除类型数据
     */
    async del(){
        const {ctx,app}=this;
        const {body}=ctx.request;
        if(!body.category_id){
            return ctx.body=ctx.helper.error_result("没有指定分类ID");
        }
        try {
            let count=await app.model.SubCategory.count({where:{category_id:body.category_id}});
            if(count>0){
                await app.model.SubCategory.destroy({
                    where:{category_id:body.category_id}
                })
            }

            let result=await app.model.Category.destroy({
                where:{
                    category_id:body.category_id
                }
            })
            ctx.body=result ? ctx.helper.success_result("删除成功",result) :ctx.helper.error_result("删除失败!") ;   
        } catch (error) {
            return ctx.body=ctx.helper.error_result("删除分类失败!");
        }
    }
    //分类信息
    /**
     * @api {get} /manage/category_info 分类信息
     * @apiName categoryInfo
     * @apiGroup Category
     * @apiVersion 1.0.0
     * @apiDescription 分类信息
     * @apiParam {Number} category_id  分类ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 查询结果数据结构
     * @apiSuccess {Object} data.category_id 分类ID
     * @apiSuccess {String} data.category_name 分类名称
     * @apiSuccess {String} data.create_time 创建时间
     * @apiSuccess {Object[]} data.sub_list 子分类列表
     * @apiSuccess {String} data.sub_list.sub_id 子分类ID
     * @apiSuccess {String} data.sub_list.sub_name 子分类名称
     * @apiSuccess {String} data.sub_list.checked 是否已经关联
     */
    async info(){
        const {ctx}=this;
        const {query}=ctx.request;
        if(!query.category_id){
            return ctx.body=ctx.helper.error_result("未指定需要查询的分类ID");
        }
        let condition={
            category_id:query.category_id
        }
        return ctx.body=await ctx.service.category.find_one(condition);
    }
    /**
     * @api {post} /manage/add_category_subs 子类父类关联
     * @apiName addCategorySub
     * @apiGroup Category
     * @apiVersion 1.0.0
     * @apiDescription 子类父类关联
     * @apiParam {Number} sub_id 子类ID(当类型ID为空时上传)
     * @apiParam {Number} category_id  类型ID(当子类型ID为空时上传)
     * @apiParam {Object[]} sub_categories  子类父类ID数组
     * @apiParam {Number} sub_categories.sub_id  子类型ID
     * @apiParam {Number} sub_categories.category_id  类型ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     *
     */
    /**
     * 过程：
     *  添加子类或分类关联记录
     *  判断对应的子类和分类信息是否存在
     * 如果存在，构建$or条件，删除对应的关联关系，用新的关联关系覆盖旧的关联关系
     */
    async add_category_subs(){
        const {ctx,app}=this;
        const {body}=ctx.request;
        const {SubCategory} =app.model
        if(!body.sub_categories||!Array.isArray(body.sub_categories)){
            return ctx.body=ctx.helper.error_result("没有指定需要关联的子类父类")
        }
        
        if(!body.sub_id&&!body.category_id){//说明是新增
            
            return ctx.body=ctx.helper.error_result("子类ID和父类ID必须传一个")
        }
        let sub_categories=body.sub_categories;
        try {
            let or_arr:object[]=[];
            if(body.sub_id){
                or_arr.push({
                    sub_id:body.sub_id
                })
            }
            if(body.category_id){
                or_arr.push({
                    category_id:body.category_id
                })
            }
            console.log(or_arr);
            
            await SubCategory.destroy({where:{[Op.or]:or_arr}});

            let arr=await SubCategory.bulkCreate(sub_categories);
            return ctx.body=ctx.helper.success_result("需关联"+sub_categories.length+"个,成功关联"+arr.length+"个");
            
        } catch (error) {
            console.log(error);
        }
        ctx.body=ctx.helper.error_result("未关联数据")
    }

    
}

